Systems for executing load instructions that achieve sequential load consistency

ABSTRACT

A method is disclosed for executing a load instruction. Address information of the load instruction is used to generate an address of needed data, and the address is used to search a cache memory for the needed data. If the needed data is found in the cache memory, a cache hit signal is generated. At least a portion of the address is used to search a queue for a previous load instruction specifying the same address. If a previous load instruction specifying the same address is found, the cache hit signal is ignored and the load instruction is stored in the queue. A load/store unit, and a processor implementing the method, are also described.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a continuation of, and claims the benefit of the filing date of, U.S. patent application Ser. No. 10/988,310 entitled METHOD AND SYSTEMS FOR EXECUTING LOAD INSTRUCTIONS THAT ACHIEVE SEQUENTIAL LOAD CONSISTENCY, filed Nov. 12, 2004 now U.S. Pat. No 7,376,816. This application relates to co-pending U.S. patent application Ser. No. 10/988,284 entitled SYSTEMS AND METHODS FOR EXECUTING LOAD INSTRUCTIONS THAT AVOID ORDER VIOLATIONS (, filed Nov. 12, 2004.

BACKGROUND OF THE INVENTION

1. Field of the Invention

This invention relates generally to data processing systems and, more particularly, to systems and methods for executing load and store instructions.

2. Description of the Related Art

Many modern processors (e.g., microprocessors) include load/store units for executing load instructions and store instructions. In general, a “load instruction” copies data from a specified location in a main memory to a register in a processor, and a “store instruction” copies data from a register in a processor to a specified main memory location.

In order to boost processor performances, the load/store units of many modern processors are adapted to support out of order executions of load and store instructions. A memory consistency model typically determines an order in which load and store instructions specifying the same memory locations must be carried out to achieve program correctness. If the ordering of load and store instruction executions is relaxed, program correctness problems occur.

For example, if two load instructions to the same address are executed out of order, and the value of the data at that address is changed between the executions of the two load instructions (e.g., by another processor), the later (i.e., younger) load will obtain an earlier (i.e., old) value, and the earlier (i.e., older) load will obtain a later (i.e., new) value. This situation is termed a “load-load order violation” or a “load-hit-load hazard.” The requirement that if a younger load instruction obtains old data, an older load instruction to the same address must not obtain new data is termed “sequential load consistency.” (See, for example, “Power4 System Microarchitecture” by J. M. Tendler et al., IBM Journal of Research and Development, Volume 46, Number 1, January 2002, pp. 5-25.) Some modern processors have dedicated hardware to avoid load-load order violations, thereby achieving sequential load consistency and helping to ensure program correctness.

A problem arises in that such dedicated hardware is typically complex and adds time delays. In view of the push toward higher processor clock frequencies and performance levels, it would be desirable to have a relatively simple method for executing load instructions that avoids load-load order violations to achieve sequential load consistency and can be implemented using a relatively small amount of additional hardware.

SUMMARY OF THE INVENTION

A method is disclosed for executing a load instruction. Address information of the load instruction is used to generate an address of needed data, and the address is used to search a cache memory for the needed data. If the needed data is found in the cache memory, a cache hit signal is generated. At least a portion of the address is used to search a queue for a previous load instruction specifying the same address. If a previous load instruction specifying the same address is found, the cache hit signal is ignored and the load instruction is stored in the queue. A load/store unit, and a processor implementing the method, are also described.

BRIEF DESCRIPTION OF THE DRAWINGS

For a more complete understanding of the present invention and the advantages thereof, reference is now made to the following Detailed Description taken in conjunction with the accompanying drawings, in which:

FIG. 1 is a diagram of one embodiment of a computer system including a processor having a load/store unit (LSU);

FIG. 2 is a diagram of one embodiment of the LSU of FIG. 1;

FIG. 3 is a diagram of the LSU of FIG. 2 illustrating one embodiment of load instruction order violation detection logic within a load miss queue; and

FIGS. 4A and 4B in combination form a flow chart of one embodiment of a method for executing a load instruction.

DETAILED DESCRIPTION

In the following discussion, numerous specific details are set forth to provide a thorough understanding of the present invention. However, those skilled in the art will appreciate that the present invention may be practiced without such specific details. In other instances, well-known elements have been illustrated in schematic or block diagram form in order not to obscure the present invention in unnecessary detail. Additionally, for the most part, details concerning network communications, electro-magnetic signaling techniques, and the like, have been omitted inasmuch as such details are not considered necessary to obtain a complete understanding of the present invention, and are considered to be within the understanding of persons of ordinary skill in the relevant art.

It is further noted that, unless indicated otherwise, all functions described herein may be performed in either hardware or software, or some combination thereof. In a preferred embodiment, however, the functions are performed by a processor, such as a computer or an electronic data processor, in accordance with code, such as computer program code, software, and/or integrated circuits that are coded to perform such functions, unless indicated otherwise.

Turning now to FIG. 1, the reference numeral 100 generally indicates one embodiment of a computer system including a processor 102 coupled to a system bus 120, and a main memory 122 also coupled to the system bus 120. In general, the processor 102 executes instructions of a defined instruction set, including load and store instructions. In one embodiment, the processor 102 executes instructions of the PowerPC™ instruction set (PowerPC is a trademark of the IBM Corporation, Armonk, N.Y.). In one particular embodiment, the processor 102 is a pipelined superscalar processor supporting speculative and out-of-order execution of instructions. The processor 102 is preferably contained within a single integrated circuit package.

In the embodiment of FIG. 1, the processor 102 includes instruction issue logic (IIL) 104, a level 1 (L1) instruction cache 106, a load/store unit (LSU) 108, a register file 112, and one or more functional unit(s) 114. In general, the L1 instruction cache 106 is used to store copies of instructions (e.g., of a computer program) stored in the main memory 122. In general, the register file 112 includes multiple registers for storing data needed for instruction execution. The one or more functional unit(s) 114 may be or include, for example, an integer unit and/or a floating point unit.

In general, the IIL 104 fetches instructions from the L1 instruction cache 106 and provides the instructions to either the LSU 108 or the functional unit(s) 114. More specifically, the IIL 104 provides load and store instructions to the LSU 108, and other types of instructions to the one or more functional unit(s) 114.

In the embodiment of FIG. 1, and as described in more detail below, the IIL 104 provides load and store instructions to the LSU 108 in program order. That is, instructions appear in a computer program in a sequential order termed “program order,” and the IIL 104 provides load and store instructions to the LSU 108 in this program order.

In the embodiment of FIG. 1, the LSU 108 includes a level 1 (L1) data cache 110. In general, the L1 data cache 110 is used to store copies of data stored in the main memory 122 and needed for instruction execution.

In the embodiment of FIG. 1, the L1 instruction cache 106 and the LSU 108 are coupled to a level 2 (L2) cache 118, generally used to store copies of instructions and associated data stored in the main memory 122. In general, L2 cache 118 obtains instructions and associated data stored in the main memory 122. The L1 instruction cache 106 obtains instructions from the L2 cache 118, and the L1 data cache 110 obtains data needed for instruction execution from the L2 cache 118.

A bus interface unit (BIU) 116 is coupled between the L2 cache 118 and the system bus 120. In general, the BIU 116 functions as an interface between the processor 102 and the system bus 120. For example, the L2 cache 118 accesses the main memory 122 via the BIU 116 and the system bus 120.

It is noted that in other embodiments, the computer system 100 may include other processors in addition to the processor 102. These additional processors may also be coupled to the system bus 120 and access the main memory 122, and may share the main memory 122 with the processor 102.

FIG. 2 is a diagram of one embodiment of the LSU 108 of FIG. 1. In general, the LSU 108 receives load and store instructions from the IIL 104 of FIG. 1, and executes the load and store instructions. In general, each load instruction includes address information corresponding to needed data. In the embodiment of FIG. 2, the LSU 108 supports out of order executions of load and store instructions, thereby achieving a high level of performance. (Store instructions may be executed out of order, but corresponding store data is written into the L1 data cache 110 in program order to preserve program correctness.)

In the embodiment of FIG. 2, the LSU 108 is pipelined. That is, the LSU 108 executes load and store instructions via a set of ordered pipeline stages performed in sequence. More specifically, in the embodiment of FIG. 2, the LSU 108 implements a pipeline including, in the order performed, a read file access (RF) stage, a first execution (EX1) stage, a second execution (EX2) stage, a third execution (EX3) stage, a fourth execution (EX4) stage, and a write back (WB) stage.

In the embodiment of FIG. 2, pipeline logic 200 implements the pipeline and handles both load and store instructions. The pipeline logic 200 includes an adder 202 and registers 204A-204F. The registers 204A-204F represent memory elements positioned between logic of the LSU 108 for synchronization.

In the RF stage, two operands specified by a load or store instruction are obtained from the register file 112. At the end of the RF stage, the operands are captured by the registers 204A and 204B, and are provided to inputs of the adder 202.

In the EX1 stage, the adder 202 adds the operands to form an effective address. In one embodiment, the effective address is a 64-bit effective address “EA<0:63>,” where bit EA<0> is the most significant bit, and EA<63> is the least significant bit. During the EX1 stage, the effective address produced by the adder 202 is provided to a level 1 (L1) tag file 210, to an address translation unit 212 and to one input of a multiplexer (MUX) 218. At the end of the EX1 stage, the address produced by the adder 202 (and other data) produced by EX1 stage logic of the LSU 108 is captured by register 204C and provided to EX2 stage logic.

The EX2, EX3, and EX4 stages are essentially additional execution stages. At the end of the EX2, EX3, and EX4 stages, the respective registers 204D, 204E, and 204F capture address and other data produced by respective EX2, EX3, and EX4 stage logic, and respectively provide the address and other data to the EX3 stage logic, the EX4 stage logic, and WB stage logic. During the WB stage, load data is provided to the register file 112 (FIG. 1), and store data is provided to the L1 data cache 110.

In general, the L1 tag file 210 stores portions of addresses (i.e., “tags”) of corresponding data stored in the L1 data cache 110. In the IBM PowerPC™ architecture, the least significant (i.e., low ordered) 12 bits of an effective address and the corresponding physical address (i.e., “real address”) are the same. If the instruction is a load instruction, the L1 tag file 210 generates a “HIT” signal during the EX2 stage indicative of whether the needed data is present in the L1 data cache 110 (i.e., indicative of a cache hit and/or miss). The L1 tag file 210 provides the HIT signal to control logic 214 and to the L2 cache 118 (FIG. 1).

If the instruction is a load instruction, the MUX 218 is controlled such that the effective address is provided to the L1 data cache 110 during the EX1 stage. If the HIT signal indicates the needed data is present in the L1 data cache 110 (i.e., indicates a cache hit), the L1 data cache 110 produces the needed data at an output during the WB stage. A multiplexer (MUX) 222 is controlled such the needed data produced by the L1 data cache 110 is provided to the register file 112 during the WB stage.

The address translation unit 212 translates the effective address, received during the EX1 stage, to a real address. During the EX4 stage, the address translation unit 212 provides the real address to the L2 cache 118 (FIG. 1), a load miss queue 206, and a store queue 216.

In the embodiment of FIG. 2, the load miss queue 206 includes a 4-entry queue 208 generally used for storing load instructions specifying corresponding data not found in the L1 data cache 110, while waiting for the corresponding data to be obtained from the L2 cache 118 (FIG. 1), and while waiting for data stored in the store queue 216 to be stored in the L1 data cache 110. In one embodiment, each entry in the queue 208 is adapted for storing load instruction information and address information.

As described above, the IIL 104 (FIG. 1) provides load and store instructions to the LSU 108 in program order. The load miss queue 206 and the store queue 216 are operated such that the relative ordering of load and store instructions is determinable.

In the embodiment of FIG. 2, the store queue 216 includes a 4-entry queue used for storing store instructions and corresponding data while waiting for a suitable time to store the corresponding data in the L1 data cache 110. In one embodiment, each entry in the store queue 216 is adapted for storing store instruction information, address information, and store data. The load miss queue 206 and the store queue 216 are described in more detail below.

In the case of a store instruction, at least a portion of the real address is stored in the store queue 216, along with corresponding store data from the register file 112. In the case of a load instruction, and the HIT signal indicates a cache miss, at least a portion of the real address is stored in the load miss queue 206. The load miss queue 206 provides queue entry information to the L2 cache 118 (FIG. 1) that specifies the entry of the queue 208 where the load instruction is stored.

Regarding each load instruction stored in the load miss queue 206, when the L2 cache 118 (FIG. 1) provides the corresponding load data, the L2 cache 118 also provides the corresponding queue entry information to the load miss queue 206. Execution of a load instruction is complete when the corresponding data is stored in the register file 112 (FIG. 1). When the L2 cache 118 provides load data corresponding to a load instruction in the load miss queue 206, the load data is stored in the L1 data cache 110. The load miss queue 206 provides the address information of the load instruction to the L1 data cache 110, and a multiplexer (MUX) 220 is controlled to provide the load data to the L1 data cache 110.

When a load instruction stored in the load miss queue 206 and having corresponding data stored in the L1 data cache 110 can be completed, the load miss queue 206 provides the address information of the load instruction to the L1 data cache 110, and the MUX 222 is controlled to provide the corresponding data to the register file 112 (FIG. 1).

In the embodiment of FIG. 2, the load miss queue 206 is operated such that load instructions stored therein that specify the same address (i.e., of a memory location where the corresponding data is stored) are carried out in program order. That is, the corresponding data of load instructions stored in the load miss queue 206 that specify the same address are provided to the register file 112 in program order. As described below, this processing of load instructions within the load miss queue 206 that specify the same address in program order helps the LSU 108 avoid load-load order violations, thereby achieving sequential load consistency.

Regarding each store instruction stored in the store queue 216, at a suitable time (with regard to instruction ordering to ensure correctness), the store queue 216 produces the address information and the corresponding data of a corresponding entry. The MUX 218 is controlled such that the address information is provided to the L1 data cache 110, and the MUX 220 is controlled such that the corresponding data is provided to the L1 data cache 110. When the corresponding data is stored in the L1 data cache 110, execution of the store instruction is complete.

FIG. 3 is a diagram of the LSU 108 of FIG. 2 illustrating one embodiment of load instruction order violation detection logic 300 within the load miss queue 206. Elements shown in FIG. 2 and described above are numbered similarly in FIG. 3. In the embodiment of FIG. 3, the order violation detection logic 300 includes multiple comparators 302 providing output signals to logic 304. In general, during the EX2 pipeline stage, the comparators 302 compare a portion of an effective address of a load instruction in the EX2 stage to corresponding portions of addresses of (previous) load instructions in the subsequent EX3, EX4, and WB stages (that did not complete), and also to corresponding portions of load instructions stored in the queue 208 of the load miss queue 206.

For example, the comparator 302A compares the portion of the effective address of the load instruction in the EX2 stage to a corresponding portion of an effective address of a load instruction in the EX3 stage, and the comparator 302B compares the portion of the effective address of the load instruction in the EX2 stage to a corresponding portion of an effective address of a load instruction in the EX4 stage. Each of the comparators 302 produces an output signal indicative of whether the portion of the effective address of the load instruction in the EX2 stage is equal to (i.e., “matches”) the corresponding portion of an address. The logic 304 produces an output “MATCH” signal indicative of whether the portion of the effective address of the load instruction in the EX2 stage matches any of the corresponding address portions.

As described above, in the IBM PowerPC™ architecture, the least significant (i.e., low ordered) 12 bits of an effective address and the corresponding real address are the same. In the embodiment of FIG. 3, the comparators 302 compare a portion of the lower ordered 12 bits of the effective address of the load instruction in the EX2 stage to corresponding portions of addresses of load instructions in the subsequent EX3, EX4, and WB stages, and also to corresponding portions of load instructions stored in the queue 208 of the load miss queue 206.

In one particular embodiment, each effective address is a 64-bit effective address denoted EA<0:63> as described above, and the comparators 302 compare bits 52-56 of the effective address of the load instruction in the EX2 stage to corresponding bits 52-56 of addresses of load instructions in the subsequent EX3, EX4, and WB stages, and also to corresponding portions of addresses of load instructions stored in the queue 208 of the load miss queue 206.

The control logic 214 receives the MATCH signal produced by the logic 304, and the HIT signal produced by the L1 tag file 210. As described above, the IIL 104 (FIG. 1) provides load and store instructions to the LSU 108 in program order, and the load miss queue 206 and the store queue 216 are operated such that the relative ordering of load and store instructions is determinable.

If the MATCH signal indicates the portion of the effective address of the load instruction in the EX2 stage matches a corresponding address portion of a (previous) load instruction in the subsequent EX3, EX4, and WB stages, or a corresponding address portion of a load instruction stored in the queue 208 of the load miss queue 206, and the HIT signal indicates a cache hit, the control logic 214 ignores the HIT signal. When the load instruction enters the EX4 stage, the address translation unit 212 provides the real address to the L2 cache 118 (FIG. 1). During the WB stage the load instruction is stored in the queue 208 of the load miss queue 206.

As described above, the load miss queue 206 is operated such that processing of load instructions stored therein that specify the same address are carried out in program order. Thus in ignoring the HIT signal for a load instruction having an address portion that matches an address portion of a load instruction either in a subsequent pipeline stage or in the load miss queue 206, and thereby forcing the load instruction into the load miss queue 206 where load instructions specifying the same address are carried out in program order, load-load order violations are advantageously avoided within the LSU 108 and sequential load consistency is guaranteed.

It is noted that in the embodiment of the LSU 108 described herein, no mechanism (e.g., additional hardware) is included to check that corresponding data at a common address specified by two load instructions executed out of order is changed between executions of the load instructions, thus load-load order violations are not positively identified. (Such additional hardware may be included in other embodiments.) In cases where the corresponding data is not changed between executions of the load instructions, the execution of the second instruction (in execution order) may be unnecessarily delayed. However, the additional hardware required (i.e., the logic of the load miss queue 206 that processes load instructions specifying the same address in program order, the comparators 302, the logic 304, and the control logic unit 214) is relatively simple and fast. Load-load order violations are avoided, thereby achieving sequential load consistency, and helping to achieve program correctness. At the same time, the overall performance of the LSU 108, and the processor 102 (FIG. 1) including the LSU 108, is relatively high.

FIGS. 4A and 4B in combination form a flow chart of one embodiment of a method 400 for executing a load instruction. The method 400 is relatively simple, effectively avoids load-load order violations thereby achieving sequential load consistency, and can advantageously be implemented by a relatively small amount of additional processor hardware. The method 400 may be implemented by the LSU 108 of FIGS. 1-3.

During a step 402 of the method 400, a load instruction is received. In general, the load instruction includes address information corresponding to needed data. The address information is used, during a step 404, to generate an address of the needed data (e.g., an effective address). During a step 406, the address is used to search a cache memory (e.g., the L1 data cache 110 of FIGS. 1-3) for the needed data. If the needed data is found in the cache memory during a decision step 408, a step 410 is performed. During the step 410, a cache hit signal is generated.

During a step 412, at least a portion of the address is used to search subsequent pipeline stages and a load miss queue (e.g., the load miss queue 206 of FIGS. 2-3) for a previous load instruction specifying the same address. A first load instruction is “previous” to a second load instruction if, in a computer program containing the first and second load instructions, the first load instruction is before the second load instruction.

If an instruction specifying the same address is found during a decision step 414, a step 416 is performed next. During the step 416, the cache hit signal is ignored, and the load instruction and the corresponding address are stored in the load miss queue. Where the load miss queue is operated such that load instructions stored therein that specify the same address are carried out in program order, as is the load miss queue 206 of FIGS. 2-3, the method 400 advantageously avoids load-load order violations, thereby achieving sequential load consistency and helping to ensure program correctness.

It is noted that the steps of the method 400 described above may be carried out in a different order. Further, some steps of the method 400 may be carried out simultaneously.

Having thus described the present invention by reference to certain of its preferred embodiments, it is noted that the embodiments disclosed are illustrative rather than limiting in nature and that a wide range of variations, modifications, changes, and substitutions are contemplated in the foregoing disclosure and, in some instances, some features of the present invention may be employed without a corresponding use of the other features. Many such variations and modifications may be considered desirable by those skilled in the art based upon a review of the foregoing description of preferred embodiments. Accordingly, it is appropriate that the appended claims be construed broadly and in a manner consistent with the scope of the invention. 

1. A load/store unit, comprising: pipeline logic configured to implement an instruction execution pipeline comprising a plurality of ordered stages carried out in sequence; a load miss queue comprising a plurality of entries for storing load instructions and corresponding addresses; a comparator coupled to receive a first address portion and a second address portion, wherein the first address portion comprises a portion of an address of a first load instruction in a particular stage of the execution pipeline, and wherein the second address portion comprises a portion of an address of a second load instruction, the comparator being configured to produce an output signal indicative of whether the first address portion is equal to the second address portion; logic coupled to receive the output signal of the comparator and configured to produce a match signal dependent upon the output signal of the comparator; and control logic coupled to receive the match signal and a hit signal indicative of whether the first load instruction specifies needed data found in the cache memory, and configured to ignore the hit signal dependent upon the match signal, thereby causing the first load instruction to be stored in the load miss queue.
 2. The load/store unit as recited in claim 1, wherein load instructions stored within the load miss queue and specifying the same addresses are processed in program order.
 3. The load/store unit as recited in claim 1, wherein the second load instruction precedes the first load instruction in a computer program containing the first and second load instructions.
 4. The load/store unit as recited in claim 1, wherein the second load instruction is stored in the load miss queue.
 5. The load/store unit as recited in claim 1, wherein the second load instruction is in a stage of the execution pipeline subsequent to the particular stage.
 6. The load/store unit as recited in claim 1, wherein the load/store unit avoids load-load order violations, thereby achieving sequential load consistency.
 7. A load/store unit, comprising: pipeline logic configured to implement an instruction execution pipeline comprising a plurality of ordered stages carried out in sequence; a load miss queue comprising a plurality of entries for storing addresses of corresponding load instructions; a first comparator coupled to receive a first address portion and a second address portion, wherein the first address portion comprises a portion of an address of a first load instruction in a particular stage of the execution pipeline, and wherein the second address portion comprises a portion of an address of a second load instruction in a stage of the execution pipeline subsequent to the particular stage, the first comparator being configured to produce an output signal indicative of whether the first address portion and the second address portion are equal; a second comparator coupled to receive the first address portion and a third address portion comprising a portion of an address of a third load instruction stored in the load miss queue, the second comparator being configured to produce an output signal indicative of whether the first address portion and the third address portion are equal; logic coupled to receive the output signals of the first and second comparators and configured to produce a match signal dependent upon the output signals of the first and second comparators; and control logic coupled to receive the match signal and a hit signal indicative of whether the first load instruction specifies needed data found in the cache memory, and configured to ignore the hit signal dependent upon the match signal, thereby causing the first load instruction to be stored in the load miss queue.
 8. The load/store unit as recited in claim 7, wherein load instructions stored within the load miss queue and specifying the same addresses are processed in program order.
 9. The load/store unit as recited in claim 7, wherein the second and third load instructions precede the first load instruction in a program containing the first, second, and third load instructions.
 10. The load/store unit as recited in claim 7, wherein the load/store unit avoids load-load order violations, thereby achieving sequential load consistency.
 11. A processor, comprising: means for receiving a first load instruction, wherein the first load instruction includes address information corresponding to needed data; means for using the address information to generate an address of the needed data; means for using the address to search a cache memory for the needed data; means for generating a cache hit signal responsive to the needed data being found in the cache memory; means for using at least a portion of the address to search an instruction pipeline and a load miss queue for a second load instruction specifying the same address and issued before the first load instruction; and means for ignoring the cache hit signal and storing the first load instruction in the load miss queue responsive to a second load instruction specifying the same address being found.
 12. The processor as recited in claim 11, wherein the means for using at least a portion of the address to search a load miss queue for a second load instruction specifying the same address comprises a plurality of comparators.
 13. The processor as recited in claim 11, wherein the means for ignoring the cache hit signal comprises control logic. 